home *** CD-ROM | disk | FTP | other *** search
/ QuickTime 1.0 for Developers / QuickTime 1.0 for Developers.iso / Programming Stuff / Interfaces / Movies Interfaces / ImageCompression.p < prev    next >
Text File  |  1991-09-06  |  22KB  |  465 lines
  1.  
  2. {
  3. Created: Tuesday, August 13, 1991 at 4:31 PM
  4.  ImageCompression.p
  5.  Pascal Interface to the Macintosh Libraries
  6.  
  7.  Copyright Apple Computer, Inc. 1991
  8.  All rights reserved
  9. }
  10.  
  11.  
  12. {$IFC UNDEFINED UsingIncludes}
  13. {$SETC UsingIncludes := 0}
  14. {$ENDC}
  15.  
  16. {$IFC NOT UsingIncludes}
  17.  UNIT ImageCompression;
  18.  INTERFACE
  19. {$ENDC}
  20.  
  21. {$IFC UNDEFINED UsingImageCompression}
  22. {$SETC UsingImageCompression := 1}
  23.  
  24. {$I+}
  25. {$SETC ImageCompressionIncludes := UsingIncludes}
  26. {$SETC UsingIncludes := 1}
  27. {$IFC UNDEFINED UsingQuickDraw}
  28. {$I $$Shell(PInterfaces)QuickDraw.p}
  29. {$ENDC}
  30. {$IFC UNDEFINED UsingQDOffscreen}
  31. {$I $$Shell(PInterfaces)QDOffscreen.p}
  32. {$ENDC}
  33. {$IFC UNDEFINED UsingTypes}
  34. {$I $$Shell(PInterfaces)Types.p}
  35. {$ENDC}
  36. {$IFC UNDEFINED UsingComponents}
  37. {$I $$Shell(PInterfaces)Components.p}
  38. {$ENDC}
  39. {$SETC UsingIncludes := ImageCompressionIncludes}
  40.  
  41. CONST
  42. gestaltCompressionMgr = 'icmp';
  43.  
  44. { These are the bits that are set in the Component flags, and also in the codecInfo struct. }
  45.  
  46. codecInfoDoes1 = $1;                    { codec can work with 1-bit pixels }
  47. codecInfoDoes2 = $2;                    { codec can work with 2-bit pixels }
  48. codecInfoDoes4 = $4;                    { codec can work with 4-bit pixels }
  49. codecInfoDoes8 = $8;                    { codec can work with 8-bit pixels }
  50. codecInfoDoes16 = $10;                    { codec can work with 16-bit pixels }
  51. codecInfoDoes32 = $20;                    { codec can work with 32-bit pixels }
  52. codecInfoDoesDither = $40;                { codec can do ditherMode }
  53. codecInfoDoesStretch = $80;                { codec can stretch to arbitrary sizes }
  54. codecInfoDoesShrink = $100;                { codec can shrink to arbitrary sizes }
  55. codecInfoDoesMask = $200;                { codec can mask to clipping regions }
  56.  
  57. codecInfoDoesTemporal = $400;            { codec can handle temporal redundancy }
  58.  
  59. codecInfoDoesDouble = $800;                { codec can stretch to double size exactly }
  60. codecInfoDoesQuad = $1000;                { codec can stretch to quadruple size exactly }
  61. codecInfoDoesHalf = $2000;                { codec can shrink to half size }
  62. codecInfoDoesQuarter = $4000;            { codec can shrink to quarter size }
  63.  
  64. codecInfoDoesRotate = $8000;            { codec can rotate on decompress }
  65. codecInfoDoesHorizFlip = $10000;        { codec can flip horizontally on decompress }
  66. codecInfoDoesVertFlip = $20000;            { codec can flip vertically on decompress }
  67. codecInfoDoesSkew = $40000;                { codec can skew on decompress }
  68. codecInfoDoesBlend = $80000;            { codec can blend on decompress }
  69. codecInfoDoesWarp = $100000;            { codec can warp arbitrarily on decompress }
  70. codecInfoDoesRecompress = $200000;        { codec can recompress image without accumulating errors }
  71.  
  72. codecInfoDepth1 = $1;                    { compressed data at 1 bpp depth available }
  73. codecInfoDepth2 = $2;                    { compressed data at 2 bpp depth available }
  74. codecInfoDepth4 = $4;                    { compressed data at 4 bpp depth available }
  75. codecInfoDepth8 = $8;                    { compressed data at 8 bpp depth available }
  76. codecInfoDepth16 = $10;                    { compressed data at 16 bpp depth available }
  77. codecInfoDepth32 = $20;                    { compressed data at 32 bpp depth available }
  78. codecInfoDepth24 = $40;                    { compressed data at 24 bpp depth available }
  79. codecInfoDepth33 = $80;                    { compressed data at 1 bpp monochrome depth  available }
  80. codecInfoDepth34 = $100;                { compressed data at 2 bpp grayscale depth available }
  81. codecInfoDepth36 = $200;                { compressed data at 4 bpp grayscale depth available }
  82. codecInfoDepth40 = $400;                { compressed data at 8 bpp grayscale depth available }
  83. codecInfoStoresClut = $800;                { compressed data can have custom cluts }
  84.  
  85. codecFlagUseImageBuffer = $1;            { (input) allocate buffer for whole image on decompress sequence }
  86. codecFlagUseScreenBuffer = $2;            { (input) allocate buffer for screen on decompress sequence for faster updates }
  87. codecFlagUpdatePrevious = $4;            { (input) udate previous buffer on compress sequence }
  88. codecFlagNoScreenUpdate = $8;            { (input) dont update screen, but do update image buffer if allocated }
  89. codecFlagWasCompressed = $10;            { (input) hint to compressor that image was previously compressed }
  90. codecFlagDontOffscreen = $20;            { return error instead of automatically going offscreen }
  91. codecFlagUpdatePreviousComp = $40;        { (input) udate previous buffer on compress sequence }
  92. codecFlagForceKeyFrame = $80;            { when sent to CompressSequenceFrame, forces that frame to be a key frame }
  93.  
  94. codecFlagUsedImageBuffer = $8000;        { (output) indicates that image buffer was used on this decompress sequence }
  95.  
  96. codecErr = -8960;                        { the codec returned an error }
  97. noCodecErr = -8961;                        { the specified codec could not be found }
  98. codecUnimpErr = -8962;                    { this feature is not implemented by the specified codec }
  99. codecSizeErr = -8963;
  100. codecScreenBufErr = -8964;                { the screen buffer could not be allocated }
  101. codecImageBufErr = -8965;                { the image buffer could not be allocated }
  102. codecSpoolErr = -8966;                    { the compressed data must be in memory (spooling did not work) }
  103. codecAbortErr = -8967;                    { the operation was aborted by the progress proc }
  104. codecWouldOffscreenErr = -8968;            { an offscreen access would have been used, but wasn't allowed because codecFlagDontOffscreen was set }
  105. codecBadDataErr = -8969;                { compressed data was found to have inconsistencies }
  106. codecDataVersErr = -8970;                { compressed data was of a format version that codec couldn't handle }
  107.  
  108. codecMinimumDataSize = 16384;            { The minimum data size for spooling in or out data }
  109.  
  110. compressorComponentType = 'imco';        { the type for "Components" which compress images }
  111. decompressorComponentType = 'imdc';        { the type for "Components" which decompress images }
  112.  
  113. TYPE
  114. CompressorComponent = Component;        { a Component which compresses images }
  115. DecompressorComponent = Component;        { a Component which decompresses images }
  116. CodecComponent = Component;                { a Component which decompresses or compresses images }
  117.  
  118. sBoolean = INTEGER;                        { to make sure stack frames are right }
  119.  
  120. CodecType = LONGINT;                    { type descriptor for codecs i.e: 'appl','jpeg','rle ' }
  121.  
  122. CodecFlags = INTEGER;                    { flags for codec manager calls }
  123.  
  124. CodecQ = LONGINT;
  125. DataProcPtr = OSErr;
  126. FlushProcPtr = OSErr;
  127.  
  128. CONST
  129. codecCompletionSource = 1;
  130. codecCompletionDest = 2;
  131.  
  132. TYPE
  133. CompletionProcPtr = ProcPtr;
  134.  
  135. CONST
  136. codecProgressOpen = 0;
  137. codecProgressUpdatePercent = 1;
  138. codecProgressClose = 2;
  139.  
  140. TYPE
  141. ProgressProcPtr = ProcPtr;
  142.  
  143. ImageSequence = LONGINT;
  144.  
  145. ProgressProcRecordPtr = ^ProgressProcRecord;
  146. ProgressProcRecord = RECORD
  147.  progressProc: ProgressProcPtr;
  148.  progressRefCon: LONGINT;
  149.  END;
  150.  
  151. CompletionProcRecordPtr = ^CompletionProcRecord;
  152. CompletionProcRecord = RECORD
  153.  completionProc: CompletionProcPtr;
  154.  completionRefCon: LONGINT;
  155.  END;
  156.  
  157. DataProcRecordPtr = ^DataProcRecord;
  158. DataProcRecord = RECORD
  159.  dataProc: DataProcPtr;
  160.  dataRefCon: LONGINT;
  161.  END;
  162.  
  163. FlushProcRecordPtr = ^FlushProcRecord;
  164. FlushProcRecord = RECORD
  165.  flushProc: FlushProcPtr;
  166.  flushRefCon: LONGINT;
  167.  END;
  168.  
  169. { 
  170.     The ImageDescription is private data which is produced when an image or sequence 
  171.     is compressed. It fully describes the format of the compressed data.}
  172.  
  173. ImageDescriptionPtr = ^ImageDescription;
  174. ImageDescriptionHandle = ^ImageDescriptionPtr;
  175. ImageDescription = RECORD
  176.  idSize: LONGINT;                        { total size of ImageDescription including extra data ( CLUTs and other per sequence data }
  177.  cType: CodecType;                        { what kind of codec compressed this data }
  178.  resvd1: LONGINT;                        { reserved for apple use }
  179.  resvd2: INTEGER;                        { reserved for apple use }
  180.  dataRefIndex: INTEGER;                    { set to zero }
  181.  version: INTEGER;                        { which version is this data }
  182.  revisionLevel: INTEGER;                { what version of that codec did this }
  183.  vendor: LONGINT;                        { whose  codec compressed this data }
  184.  temporalQuality: CodecQ;                { what was the temporal quality factor          }
  185.  spatialQuality: CodecQ;                { what was the spatial quality factor          }
  186.  width: INTEGER;                        { how many pixels wide is this data }
  187.  height: INTEGER;                        { how many pixels high is this data }
  188.  hRes: Fixed;                            { horizontal resolution }
  189.  vRes: Fixed;                            { vertical resolution }
  190.  dataSize: LONGINT;                        { if known, the size of data for this image descriptor }
  191.  frameCount: INTEGER;                    { number of frames this description applies to }
  192.  name: ARRAY [0..31] OF CHAR;            { name of codec ( in case not installed ) }
  193.  depth: INTEGER;                        { what depth is this data (1-32) or ( 33-40 grayscale ) }
  194.  clutID: INTEGER;                        { clut id or if 0 clut follows  or -1 if no clut }
  195.  END;
  196.  
  197. { 
  198.     The CodecInfo is the information returned as the codecInfo struct by a codec Component
  199.     to the codec manager or to the caller. It is specific to the particular codec
  200.     implementation and not to the codec type.}
  201.  
  202. CodecInfo = RECORD
  203.  typeName: ARRAY [0..31] OF CHAR;        { name of the codec type i.e.: 'Apple Image Compression' }
  204.  version: INTEGER;                        { version of the codec data that this codec knows about }
  205.  revisionLevel: INTEGER;                { revision level of this codec i.e: 0x00010001 (1.0.1) }
  206.  vendor: LONGINT;                        { Maker of this codec i.e: 'appl' }
  207.  decompressFlags: LONGINT;                { codecInfo flags for decompression capabilities }
  208.  compressFlags: LONGINT;                { codecInfo flags for compression capabilities }
  209.  formatFlags: LONGINT;                    { codecInfo flags for compression format details }
  210.  compressionAccuracy: CHAR;                { measure (1-255) of accuracy of this codec for compress (0 if unknown) }
  211.  decompressionAccuracy: CHAR;            { measure (1-255) of accuracy of this codec for decompress (0 if unknown) }
  212.  compressionSpeed: INTEGER;                { ( millisecs for compressing 320x240 on base mac II) (0 if unknown) }
  213.  decompressionSpeed: INTEGER;            { ( millisecs for decompressing 320x240 on mac II)(0 if unknown) }
  214.  compressionLevel: CHAR;                { measure (1-255) of compression level of this codec (0 if unknown) }
  215.  resvd: CHAR;                            { pad }
  216.  minimumHeight: INTEGER;                { minimum height of image (block size) }
  217.  minimumWidth: INTEGER;                    { minimum width of image (block size) }
  218.  decompressPipelineLatency: INTEGER;    { in milliseconds ( for asynchronous codecs ) }
  219.  compressPipelineLatency: INTEGER;        { in milliseconds ( for asynchronous codecs ) }
  220.  privateData: LONGINT;
  221.  END;
  222.  
  223. { Table used for fast dithering. }
  224. DTabPtr = ^DitherTable;
  225. DTabHandle = ^DTabPtr;
  226. DitherTable = RECORD
  227.  tag: LONGINT;
  228.  seed: LONGINT;
  229.  reserved: LONGINT;
  230.  data: ARRAY [0..0] OF CHAR;
  231.  END;
  232.  
  233. { Name list returned by GetCodecNameList. }
  234. CodecNameSpec = RECORD
  235.  codec: CodecComponent;
  236.  cType: CodecType;
  237.  typeName: ARRAY [0..31] OF CHAR;
  238.  name: Handle;
  239.  END;
  240.  
  241. CodecNameSpecListPtr = ^CodecNameSpecList;
  242. CodecNameSpecList = RECORD
  243.  count: INTEGER;
  244.  list: ARRAY [0..0] OF CodecNameSpec;
  245.  END;
  246.  
  247. {  Matrix stuff  }
  248. MatrixRecordPtr = ^MatrixRecord;
  249. MatrixRecord = RECORD
  250.  matrix: ARRAY [0..2,0..2] OF Fixed;
  251.  END;
  252.  
  253. FixedPoint = RECORD
  254.  x: Fixed;
  255.  y: Fixed;
  256.  END;
  257.  
  258. FixedRect = RECORD
  259.  left: Fixed;
  260.  top: Fixed;
  261.  right: Fixed;
  262.  bottom: Fixed;
  263.  END;
  264.  
  265.  
  266. FUNCTION CodecManagerVersion(VAR version: LONGINT): OSErr;
  267.  INLINE $7000+$0000,$AAA3;
  268. FUNCTION GetCodecNameList(VAR list: CodecNameSpecListPtr;showAll: sBoolean): OSErr;
  269.  INLINE $7000+$0001,$AAA3;
  270. FUNCTION GetCodecInfo(VAR info: CodecInfo;cType: CodecType;codec: CodecComponent): OSErr;
  271.  INLINE $7000+$0003,$AAA3;
  272. FUNCTION GetMaxCompressionSize(src: PixMapHandle;VAR srcRect: Rect;colorDepth: INTEGER;
  273.  quality: CodecQ;cType: CodecType;codec: CompressorComponent;VAR size: LONGINT): OSErr;
  274.  INLINE $7000+$0004,$AAA3;
  275. FUNCTION GetCompressionTime(src: PixMapHandle;VAR srcRect: Rect;colorDepth: INTEGER;
  276.  cType: CodecType;codec: CompressorComponent;VAR spatialQuality: CodecQ;
  277.  VAR temporalQuality: CodecQ;VAR compressTime: LONGINT): OSErr;
  278.  INLINE $7000+$0005,$AAA3;
  279. FUNCTION CompressImage(src: PixMapHandle;VAR srcRect: Rect;quality: CodecQ;
  280.  cType: CodecType;desc: ImageDescriptionHandle;data: Ptr): OSErr;
  281.  INLINE $7000+$0006,$AAA3;
  282. FUNCTION FCompressImage(src: PixMapHandle;VAR srcRect: Rect;colorDepth: INTEGER;
  283.  quality: CodecQ;cType: CodecType;codec: CompressorComponent;clut: CTabHandle;
  284.  flags: CodecFlags;bufferSize: LONGINT;flushProc: FlushProcRecordPtr;progressProc: ProgressProcRecordPtr;
  285.  desc: ImageDescriptionHandle;data: Ptr): OSErr;
  286.  INLINE $7000+$0007,$AAA3;
  287. FUNCTION DecompressImage(data: Ptr;desc: ImageDescriptionHandle;dst: PixMapHandle;
  288.  VAR srcRect: Rect;VAR dstRect: Rect;mode: INTEGER;mask: RgnHandle): OSErr;
  289.  INLINE $7000+$0008,$AAA3;
  290. FUNCTION FDecompressImage(data: Ptr;desc: ImageDescriptionHandle;dst: PixMapHandle;
  291.  VAR srcRect: Rect;matrix: MatrixRecordPtr;mode: INTEGER;mask: RgnHandle;
  292.  matte: PixMapHandle;VAR matteRect: Rect;accuracy: CodecQ;codec: DecompressorComponent;
  293.  bufferSize: LONGINT;dataProc: DataProcRecordPtr;progressProc: ProgressProcRecordPtr): OSErr;
  294.  INLINE $7000+$0009,$AAA3;
  295. FUNCTION CompressSequenceBegin(VAR seqID: ImageSequence;src: PixMapHandle;
  296.  prev: PixMapHandle;VAR srcRect: Rect;VAR prevRect: Rect;colorDepth: INTEGER;
  297.  cType: CodecType;codec: CompressorComponent;spatialQuality: CodecQ;temporalQuality: CodecQ;
  298.  keyFrameRate: LONGINT;clut: CTabHandle;flags: CodecFlags;desc: ImageDescriptionHandle): OSErr;
  299.  INLINE $7000+$000A,$AAA3;
  300. FUNCTION CompressSequenceFrame(seqID: ImageSequence;src: PixMapHandle;VAR srcRect: Rect;
  301.  flags: CodecFlags;data: Ptr;VAR dataSize: LONGINT;VAR similarity: CHAR;
  302.  asyncCompletionProc: CompletionProcRecordPtr): OSErr;
  303.  INLINE $7000+$000B,$AAA3;
  304. FUNCTION DecompressSequenceBegin(VAR seqID: ImageSequence;desc: ImageDescriptionHandle;
  305.  port: CGrafPtr;gdh: GDHandle;VAR srcRect: Rect;matrix: MatrixRecordPtr;
  306.  mode: INTEGER;mask: RgnHandle;flags: CodecFlags;accuracy: CodecQ;codec: DecompressorComponent): OSErr;
  307.  INLINE $7000+$000D,$AAA3;
  308. FUNCTION DecompressSequenceFrame(seqID: ImageSequence;data: Ptr;inFlags: CodecFlags;
  309.  VAR outFlags: CodecFlags;asyncCompletionProc: CompletionProcRecordPtr): OSErr;
  310.  INLINE $7000+$000E,$AAA3;
  311. FUNCTION SetDSequenceMatrix(seqID: ImageSequence;matrix: MatrixRecordPtr): OSErr;
  312.  INLINE $7000+$0010,$AAA3;
  313. FUNCTION SetDSequenceMatte(seqID: ImageSequence;matte: PixMapHandle;VAR matteRect: Rect): OSErr;
  314.  INLINE $7000+$0011,$AAA3;
  315. FUNCTION SetDSequenceMask(seqID: ImageSequence;mask: RgnHandle): OSErr;
  316.  INLINE $7000+$0012,$AAA3;
  317. FUNCTION SetDSequenceTransferMode(seqID: ImageSequence;mode: INTEGER;VAR opColor: RGBColor): OSErr;
  318.  INLINE $7000+$0013,$AAA3;
  319. FUNCTION SetDSequenceDataProc(seqID: ImageSequence;dataProc: DataProcRecordPtr;
  320.  bufferSize: LONGINT): OSErr;
  321.  INLINE $7000+$0014,$AAA3;
  322. FUNCTION SetDSequenceAccuracy(seqID: ImageSequence;accuracy: CodecQ): OSErr;
  323.  INLINE $7000+$0034,$AAA3;
  324. FUNCTION SetDSequenceSrcRect(seqID: ImageSequence;VAR srcRect: Rect): OSErr;
  325.  INLINE $7000+$0035,$AAA3;
  326. FUNCTION GetDSequenceImageBuffer(seqID: ImageSequence;VAR gworld: GWorldPtr): OSErr;
  327.  INLINE $7000+$0015,$AAA3;
  328. FUNCTION GetDSequenceScreenBuffer(seqID: ImageSequence;VAR gworld: GWorldPtr): OSErr;
  329.  INLINE $7000+$0016,$AAA3;
  330. FUNCTION SetCSequenceQuality(seqID: ImageSequence;spatialQuality: CodecQ;
  331.  temporalQuality: CodecQ): OSErr;
  332.  INLINE $7000+$0017,$AAA3;
  333. FUNCTION SetCSequencePrev(seqID: ImageSequence;prev: PixMapHandle;VAR prevRect: Rect): OSErr;
  334.  INLINE $7000+$0018,$AAA3;
  335. FUNCTION SetCSequenceFlushProc(seqID: ImageSequence;flushProc: FlushProcRecordPtr;
  336.  bufferSize: LONGINT): OSErr;
  337.  INLINE $7000+$0033,$AAA3;
  338. FUNCTION SetCSequenceKeyFrameRate(seqID: ImageSequence;keyframerate: LONGINT): OSErr;
  339.  INLINE $7000+$0036,$AAA3;
  340. FUNCTION GetCSequencePrevBuffer(seqID: ImageSequence;VAR gworld: GWorldPtr): OSErr;
  341.  INLINE $7000+$0019,$AAA3;
  342. FUNCTION CDSequenceBusy(seqID: ImageSequence): OSErr;
  343.  INLINE $7000+$001A,$AAA3;
  344. FUNCTION CDSequenceEnd(seqID: ImageSequence): OSErr;
  345.  INLINE $7000+$001B,$AAA3;
  346. FUNCTION GetCompressedImageSize(desc: ImageDescriptionHandle;data: Ptr;
  347.  bufferSize: LONGINT;dataProc: DataProcRecordPtr;VAR dataSize: LONGINT): OSErr;
  348.  INLINE $7000+$001C,$AAA3;
  349. FUNCTION GetSimilarity(src: PixMapHandle;VAR srcRect: Rect;desc: ImageDescriptionHandle;
  350.  data: Ptr;VAR similarity: Fixed): OSErr;
  351.  INLINE $7000+$001D,$AAA3;
  352. FUNCTION GetImageDescriptionCTable(desc: ImageDescriptionHandle;VAR ctable: CTabHandle): OSErr;
  353.  INLINE $7000+$001E,$AAA3;
  354. FUNCTION SetImageDescriptionCTable(desc: ImageDescriptionHandle;ctable: CTabHandle): OSErr;
  355.  INLINE $7000+$001F,$AAA3;
  356. FUNCTION GetImageDescriptionExtension(desc: ImageDescriptionHandle;VAR extension: Handle;
  357.  idType: LONGINT;index: LONGINT): OSErr;
  358.  INLINE $7000+$0020,$AAA3;
  359. FUNCTION SetImageDescriptionExtension(desc: ImageDescriptionHandle;extension: Handle;
  360.  idType: LONGINT): OSErr;
  361.  INLINE $7000+$0021,$AAA3;
  362. FUNCTION FindCodec(cType: CodecType;specCodec: CodecComponent;VAR compressor: CompressorComponent;
  363.  VAR decompressor: DecompressorComponent): OSErr;
  364.  INLINE $7000+$0023,$AAA3;
  365. FUNCTION CompressPicture(srcPicture: PicHandle;dstPicture: PicHandle;quality: CodecQ;
  366.  cType: CodecType): OSErr;
  367.  INLINE $7000+$0024,$AAA3;
  368. FUNCTION FCompressPicture(srcPicture: PicHandle;dstPicture: PicHandle;colorDepth: INTEGER;
  369.  clut: CTabHandle;quality: CodecQ;doDither: sBoolean;compressAgain: sBoolean;
  370.  progressProc: ProgressProcRecordPtr;cType: CodecType;codec: CompressorComponent): OSErr;
  371.  INLINE $7000+$0025,$AAA3;
  372. FUNCTION CompressPictureFile(srcRefNum: INTEGER;dstRefNum: INTEGER;quality: CodecQ;
  373.  cType: CodecType): OSErr;
  374.  INLINE $7000+$0026,$AAA3;
  375. FUNCTION FCompressPictureFile(srcRefNum: INTEGER;dstRefNum: INTEGER;colorDepth: INTEGER;
  376.  clut: CTabHandle;quality: CodecQ;doDither: sBoolean;compressAgain: sBoolean;
  377.  progressProc: ProgressProcRecordPtr;cType: CodecType;codec: CompressorComponent): OSErr;
  378.  INLINE $7000+$0027,$AAA3;
  379. FUNCTION GetPictureFileHeader(refNum: INTEGER;VAR frame: Rect;VAR header: OpenCPicParams): OSErr;
  380.  INLINE $7000+$0028,$AAA3;
  381. FUNCTION DrawPictureFile(refNum: INTEGER;VAR frame: Rect;progressProc: ProgressProcRecordPtr): OSErr;
  382.  INLINE $7000+$0029,$AAA3;
  383. FUNCTION DrawTrimmedPicture(srcPicture: PicHandle;VAR frame: Rect;trimMask: RgnHandle;
  384.  doDither: sBoolean;progressProc: ProgressProcRecordPtr): OSErr;
  385.  INLINE $7000+$002E,$AAA3;
  386. FUNCTION DrawTrimmedPictureFile(srcRefnum: INTEGER;VAR frame: Rect;trimMask: RgnHandle;
  387.  doDither: sBoolean;progressProc: ProgressProcRecordPtr): OSErr;
  388.  INLINE $7000+$002F,$AAA3;
  389. FUNCTION MakeThumbnailFromPicture(picture: PicHandle;colorDepth: INTEGER;
  390.  thumbnail: PicHandle;progressProc: ProgressProcRecordPtr): OSErr;
  391.  INLINE $7000+$002A,$AAA3;
  392. FUNCTION MakeThumbnailFromPictureFile(refNum: INTEGER;colorDepth: INTEGER;
  393.  thumbnail: PicHandle;progressProc: ProgressProcRecordPtr): OSErr;
  394.  INLINE $7000+$002B,$AAA3;
  395. FUNCTION MakeThumbnailFromPixMap(src: PixMapHandle;VAR srcRect: Rect;colorDepth: INTEGER;
  396.  thumbnail: PicHandle;progressProc: ProgressProcRecordPtr): OSErr;
  397.  INLINE $7000+$002C,$AAA3;
  398. FUNCTION TrimImage(desc: ImageDescriptionHandle;inData: Ptr;inBufferSize: LONGINT;
  399.  dataProc: DataProcRecordPtr;outData: Ptr;outBufferSize: LONGINT;flushProc: FlushProcRecordPtr;
  400.  VAR trimRect: Rect;progressProc: ProgressProcRecordPtr): OSErr;
  401.  INLINE $7000+$002D,$AAA3;
  402. FUNCTION ConvertImage(srcDD: ImageDescriptionHandle;srcData: Ptr;colorDepth: INTEGER;
  403.  clut: CTabHandle;accuracy: CodecQ;quality: CodecQ;cType: CodecType;codec: CodecComponent;
  404.  dstDD: ImageDescriptionHandle;dstData: Ptr): OSErr;
  405.  INLINE $7000+$0030,$AAA3;
  406. FUNCTION MakeDitherTable(gdev: GDHandle;VAR ditherTable: DTabHandle): OSErr;
  407.  INLINE $7000+$0031,$AAA3;
  408. FUNCTION DisposeDitherTable(ditherTable: DTabHandle): OSErr;
  409.  INLINE $7000+$0032,$AAA3;
  410. FUNCTION GetCompressedPixMapInfo(pix: PixMapPtr;VAR desc: ImageDescriptionHandle;
  411.  VAR data: Ptr;VAR bufferSize: LONGINT;VAR dataProc: DataProcRecord;VAR progressProc: ProgressProcRecord): OSErr;
  412.  INLINE $7000+$0037,$AAA3;
  413. FUNCTION SetCompressedPixMapInfo(pix: PixMapPtr;desc: ImageDescriptionHandle;
  414.  data: Ptr;bufferSize: LONGINT;dataProc: DataProcRecordPtr;progressProc: ProgressProcRecordPtr): OSErr;
  415.  INLINE $7000+$0038,$AAA3;
  416. FUNCTION GetMatrixType(VAR m: MatrixRecord): INTEGER;
  417.  INLINE $7014,$ABC2;
  418. PROCEDURE CopyMatrix(VAR m1: MatrixRecord;VAR m2: MatrixRecord);
  419.  INLINE $7020,$ABC2;
  420. FUNCTION EqualMatrix(VAR m1: MatrixRecord;VAR m2: MatrixRecord): BOOLEAN;
  421.  INLINE $7021,$ABC2;
  422. PROCEDURE SetIdentityMatrix(VAR matrix: MatrixRecord);
  423.  INLINE $7015,$ABC2;
  424. PROCEDURE TranslateMatrix(VAR m: MatrixRecord;deltaH: Fixed;deltaV: Fixed);
  425.  INLINE $7019,$ABC2;
  426. PROCEDURE TranslateMatrixTo(VAR m: MatrixRecord;deltaH: Fixed;deltaV: Fixed);
  427.  INLINE $701A,$ABC2;
  428. PROCEDURE RotateMatrix(VAR m: MatrixRecord;degrees: Fixed;aboutX: Fixed;
  429.  aboutY: Fixed);
  430.  INLINE $7016,$ABC2;
  431. PROCEDURE ScaleMatrix(VAR m: MatrixRecord;scaleX: Fixed;scaleY: Fixed;aboutX: Fixed;
  432.  aboutY: Fixed);
  433.  INLINE $7017,$ABC2;
  434. PROCEDURE SkewMatrix(VAR m: MatrixRecord;skewX: Fixed;skewY: Fixed;aboutX: Fixed;
  435.  aboutY: Fixed);
  436.  INLINE $7018,$ABC2;
  437. FUNCTION TransformFixedPoints(VAR m: MatrixRecord;VAR fpt: FixedPoint;count: LONGINT): OSErr;
  438.  INLINE $7022,$ABC2;
  439. FUNCTION TransformPoints(VAR mp: MatrixRecord;VAR pt1: Point;count: LONGINT): OSErr;
  440.  INLINE $7023,$ABC2;
  441. FUNCTION TransformFixedRect(VAR m: MatrixRecord;VAR fr: FixedRect;VAR fpp: FixedPoint): BOOLEAN;
  442.  INLINE $7024,$ABC2;
  443. FUNCTION TransformRect(VAR m: MatrixRecord;VAR r: Rect;VAR fpp: FixedPoint): BOOLEAN;
  444.  INLINE $7025,$ABC2;
  445. FUNCTION TransformRgn(VAR mp: MatrixRecord;r: RgnHandle): OSErr;
  446.  INLINE $7000+$0039,$AAA3;
  447. FUNCTION InverseMatrix(VAR m: MatrixRecord;VAR im: MatrixRecord): BOOLEAN;
  448.  INLINE $701C,$ABC2;
  449. PROCEDURE ConcatMatrix(VAR a: MatrixRecord;VAR b: MatrixRecord);
  450.  INLINE $701B,$ABC2;
  451. PROCEDURE RectMatrix(VAR matrix: MatrixRecord;VAR srcRect: Rect;VAR dstRect: Rect);
  452.  INLINE $701E,$ABC2;
  453. PROCEDURE MapMatrix(VAR matrix: MatrixRecord;VAR fromRect: Rect;VAR toRect: Rect);
  454.  INLINE $701D,$ABC2;
  455. PROCEDURE AlignMatrix(VAR mrp: MatrixRecord;VAR srcRect: Rect);
  456.  INLINE $701F,$ABC2;
  457.  
  458.  
  459. {$ENDC} { UsingImageCompression }
  460.  
  461. {$IFC NOT UsingIncludes}
  462.  END.
  463. {$ENDC}
  464.  
  465.